<!DOCTYPE html>
<html lang="zh-CN">


<head><meta name="generator" content="Hexo 3.9.0">
  <meta charset="UTF-8">
  <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">
  <meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=no">
  <title>
    C与C++整理 | Haitao Space
  </title>
  <meta name="description" content="Stay hungry, stay foolish.">
  
  <meta name="keywords" content="
  C/C++
  ">
  
  <meta name="author" content="haitaoW">

  <meta http-equiv="Cache-Control" content="no-transform">
  <meta http-equiv="Cache-Control" content="no-siteapp">
  <meta name="theme-color" content="#1e2327">
  <link rel="apple-touch-icon" href="https://github.githubassets.com/apple-touch-icon.png">
  <link rel="apple-touch-icon" sizes="180x180" href="https://github.githubassets.com/apple-touch-icon-180x180.png">

  <link rel="icon" type="image/x-icon" href="https://assets-cdn.github.com/favicon.ico">
  <link rel="stylesheet" href="/css/main.css">
  <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/font-awesome/4.7.0/css/font-awesome.min.css">
  

  

  <script src="//cdnjs.cloudflare.com/ajax/libs/vue/1.0.25-csp/vue.min.js"></script>
  <script src="//cdnjs.cloudflare.com/ajax/libs/moment.js/2.11.2/moment.min.js"></script>
</head>

<body id="replica-app">

<nav class="navbar-wrapper">
  <div class="navbar">
    <div class="container clearfix">
      <a href="/" class="navbar-logo"><i class="fa fa-github"></i></a>

      <div class="navbar-search float-left desktop-only">
        <div class="navbar-search-form">
          <label for="gsc-i-id1">This website</label>
          <div id="google-search">
            <gcse:search></gcse:search>
          </div>
        </div>
      </div>

      <ul class="navbar-nav float-left">
        
        <li><a href="/archives">Archives</a></li>
        
        
        <li><a href="/categories">Categories</a></li>
        
        
        <li><a href="/tags">Tags</a></li>
        
        
        <li class="desktop-only"><a href="/atom.xml" target="_blank">RSS</a></li>
        
      </ul>

      <ul class="navbar-nav user-nav float-right desktop-only">
        <li class="user-nav-notification">
          <a><span class="user-nav-unread"></span><i class="fa fa-bell"></i></a>
        </li>
        <li>
          <a><i class="fa fa-plus"></i> <i class="fa fa-caret-down"></i></a>
        </li>
        <li class="user-nav-logo">
          <a><img src="https://ws1.sinaimg.cn/large/006VKYWFly1g5b0lv0x0qj30rs0mn4gt.jpg"> <i class="fa fa-caret-down"></i></i></a>
        </li>
      </ul>
    </div>
  </div>
</nav>

<div class="main-container">
  <header class="header-wrapper desktop-only">
  <div class="container header-site-detail">
    <ul class="header-toolbar">
      <li class="clearfix">
        <a href="/archives" class="header-toolbar-left"><i
                  class="fa fa-file-text"></i> Posts </a>
        <a href="/archives"
           class="header-toolbar-right"> 10 </a>
      </li>
      <li>
        <a href="/tags" class="header-toolbar-left"><i
                  class="fa fa-tags"></i> Tags </a>
        <a href="/tags"
           class="header-toolbar-right"> 8 </a>
      </li>
      <li>
        <a href="/categories" class="header-toolbar-left"><i
                  class="fa fa-folder-open"></i> Categories </a>
        <a href="/categories"
           class="header-toolbar-right"> 5 </a>
      </li>
    </ul>
    <h2 class="header-title">
      <i class="fa fa-book text-muted"></i>
      <a href="/">Haitao Space</a>
      
      
    </h2>
  </div>

  <div class="container">
    <div class="header-tab-wrapper clearfix">
      <span class="header-tab header-tab-selected"><i class="fa fa-thumbs-o-up"></i> Like</span>
      <span class="header-tab"><i class="fa fa-share-alt"></i> Share</span>
      <span class="header-tab"><i class="fa fa-comments-o"></i> Discussion</span>
      <span class="header-tab"><i class="fa fa-bookmark-o"></i> Bookmark </span>
      <span class="header-tab"><i class="fa fa-smile-o"></i> Smile <i class="fa fa-caret-down"></i></span>
    </div>
  </div>
</header>


<div class="post-container container">
  <h3>
    <i class="fa fa-user-o"></i>
    haitaoW

    <span class="post-date float-right" title="{{moment(1564842393000).format('MMM DD, YYYY, h:mm:ss A')}}">
      <i class="fa fa-pencil-square-o"></i>
      {{moment(1564842393000).fromNow()}}
    </span>
  </h3>

  <article class="post-content">
    <h1>C与C++整理</h1>
    <blockquote>
<p>目录：</p>
<ol>
<li>引用与指针的区别</li>
</ol>
</blockquote>
<h4 id="1-引用与指针的区别"><a href="#1-引用与指针的区别" class="headerlink" title="1. 引用与指针的区别"></a>1. 引用与指针的区别</h4><ol>
<li><h5 id="是什么："><a href="#是什么：" class="headerlink" title="是什么："></a><strong>是什么</strong>：</h5><ol>
<li>指针是一个实体，需要分配内存空间，使用指针之前需要进行类型检查，避免出现野指针；引用只是变量的别名，不需要分配空间，引用底层是通过指针实现的；</li>
<li>sizeof 引用得到的是所指向的变量（对象）的大小，而sizeof指针得到的是指针本身的大小；</li>
</ol>
</li>
<li><h5 id="初始化："><a href="#初始化：" class="headerlink" title="初始化："></a>初始化：</h5><ol>
<li>引用定义的时候必须进行初始化，并且不能够改变，指针在定义的时候不一定要初始化，且指向的空间可变；</li>
<li>有多级指针，但是没有多级引用，只有一级引用；</li>
</ol>
</li>
<li><h5 id="传参与访问："><a href="#传参与访问：" class="headerlink" title="传参与访问："></a>传参与访问：</h5><ol>
<li>引用访问一个变量是直接访问的，而指针访问一个变量是间接访问的；</li>
<li>作为参数时，传指针的实质是传值，传递的值是指针的地址，形参会在栈中开辟内存空间以存放实参值。</li>
<li>传引用的实质是传地址，被调函数对形参的处理都是间接寻址，即通过栈中存放的地址访问主调函数中的实参变量。</li>
</ol>
</li>
</ol>
<h4 id="2-静态成员变量"><a href="#2-静态成员变量" class="headerlink" title="2.  静态成员变量"></a>2.  静态成员变量</h4><ol>
<li><h5 id="静态成员变量的初始化"><a href="#静态成员变量的初始化" class="headerlink" title="静态成员变量的初始化"></a>静态成员变量的初始化</h5><p>静态成员变量与全局变量一样，存放在全局区域，编译阶段分配内存；<strong>C与C++在初始化节点有不同</strong>：C语言中，分配好内存之后就会进行初始化，程序结束，变量所处的全局内存被回收。C++中，全局或静态对象首次用到时才会进行构造，程序结束是，按照构造顺序反方向析构。</p>
</li>
</ol>
<h4 id="3-static-关键字的作用与用法"><a href="#3-static-关键字的作用与用法" class="headerlink" title="3. static 关键字的作用与用法"></a>3. static 关键字的作用与用法</h4><ol>
<li><p><strong>作用</strong>：</p>
</li>
<li><p>隐藏，在编译多个文件时，未加static 的前缀的全局变量和函数都是全局可见的，也就是说，加了之后就只能在自己文件中使用。</p>
<ol start="2">
<li>默认初始化的值为0；</li>
<li>保持变量内容的持久性。</li>
</ol>
</li>
<li><p><strong>C++中的</strong>类成员变量声明static</p>
<ol>
<li>函数体内的static 变量的作用域范畴在函数中，该变量的内存只分配一次，因此其值在下次调用时仍然维持上次的值。</li>
<li>在类中的static成员变量属于整个类拥有，对类的所有对象职业后一份拷贝；</li>
<li>static 成员函数属于整个类所拥有，不属于对象，这个函数不接受this 指针，不能访问非static类成员只能访问类的static成员变量。</li>
<li>static 类对象必须在类外进行初始化，static修饰的变量先于对象存在，所以static修饰的变量要在类外初始化。</li>
<li>static 成员函数不能被virtual 修饰，static 成员函数不属于任何对象或实例。静态成员函数没有this指针，虚函数的实现是每一个对象分配一个vptr 指针，而vptr 是通过this指针调用的，所以不能为virtual；</li>
</ol>
</li>
</ol>
<h4 id="4-关键字const"><a href="#4-关键字const" class="headerlink" title="4. 关键字const"></a>4. 关键字const</h4><ol>
<li>阻止一个变量改变</li>
<li>以下是const  指针等生命含义：</li>
</ol>
<figure class="highlight c++"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">const</span> <span class="keyword">int</span> a;			<span class="comment">//a为常整形数，是不可以改变的</span></span><br><span class="line"><span class="keyword">int</span> <span class="keyword">const</span> a;			<span class="comment">//和上面的一样</span></span><br><span class="line"><span class="keyword">const</span> <span class="keyword">int</span> *a;			<span class="comment">// a是一个指向长整形的指针，</span></span><br><span class="line"><span class="keyword">int</span> *<span class="keyword">const</span> a;			<span class="comment">//const </span></span><br><span class="line"><span class="keyword">const</span> <span class="keyword">int</span> * <span class="keyword">const</span> a;</span><br><span class="line"><span class="keyword">int</span> <span class="keyword">const</span> * <span class="keyword">const</span> a;</span><br></pre></td></tr></table></figure>

<ol start="3">
<li>对于类的成员函数，如果指定为const类型，则表明是一个常函数，不能修改类的成员变量，类的常对象智能访问类的常成员函数；</li>
<li>const 类型成员可以通过类型转换符const_cast 将const类型转换为非const类型。</li>
</ol>
<h4 id="5-mutable用法"><a href="#5-mutable用法" class="headerlink" title="5. mutable用法"></a>5. mutable用法</h4><ol>
<li>如果需要在const 成员方法中修改一个半成员变量的值，那么需要将这个成员函数修饰为mutable，及用mutable修饰的成员变量不受const 成员方法的限制。</li>
</ol>
<h4 id="6-深拷贝与浅拷贝"><a href="#6-深拷贝与浅拷贝" class="headerlink" title="6. 深拷贝与浅拷贝"></a>6. 深拷贝与浅拷贝</h4><ol>
<li>浅拷贝：仅仅指向被复制的内存地址，如果地址中对象被改变了，那么浅复制出来的结果也会被相应改变。</li>
<li>深拷贝：在计算机中开辟一块新的内存地址用于存放复制对象。</li>
</ol>
<h4 id="7-C-模板底层实现方法"><a href="#7-C-模板底层实现方法" class="headerlink" title="7. C++ 模板底层实现方法"></a>7. C++ 模板底层实现方法</h4><p>编译过程中，编译器会对函数模板进行两次编译: 在声明的地方对模板本身就行编译，在调用的地方对参数替换后的代码进行编译，在调用的地方对参数替换后的代码进行编译。</p>
<h4 id="8-C语言struct与C-中的struct的区别"><a href="#8-C语言struct与C-中的struct的区别" class="headerlink" title="8. C语言struct与C++ 中的struct的区别"></a>8. C语言struct与C++ 中的struct的区别</h4><ol>
<li>C语言中：struct是用户自定义数据类型（UDT）；C++支持成员函数的定义；</li>
<li>C中struct是没有权限设置的，且struct只是一些变量的集合体，可以封装函数却不可以隐藏函数。C++中，struct的成员函数默认访问说明符为public。</li>
<li>在C语言中必须在结构标志前加上struct，才能做结构类型名。</li>
</ol>
<h4 id="9-虚函数可以声明为inline吗？"><a href="#9-虚函数可以声明为inline吗？" class="headerlink" title="9. 虚函数可以声明为inline吗？"></a>9. 虚函数可以声明为inline吗？</h4><p>A: 不可以</p>
<ol>
<li>虚函数用于实现运行时候的多态，或者成为晚绑定或是动态绑定。而内联函数用于提高代码效率，在编译期间对调用内联函数的地方代码替换成函数代码。</li>
<li>虚函数要求在运行时候进行类型确定，而内联函数要求在编译期间完成相关函数的替换。</li>
</ol>
<h4 id="10-类成员初始化的两种方式"><a href="#10-类成员初始化的两种方式" class="headerlink" title="10. 类成员初始化的两种方式"></a>10. 类成员初始化的两种方式</h4><p>两种方式：</p>
<ol>
<li><p>通过在函数体内进行赋值初始化，即在构造函数中进行赋值操作；2.初始化函数列表，是纯粹的初始化操作。</p>
<p>C++的赋值操作会产生临时对象，临时对象的出现会降低程序的效率。 </p>
</li>
</ol>
<h4 id="11-成员列表初始化"><a href="#11-成员列表初始化" class="headerlink" title="11.成员列表初始化"></a>11.成员列表初始化</h4><ol>
<li><p>编译器会一一操作初始化列表，以适当的顺序在构造函数之内安插初始化操作，并且在任何显示用户代码之前。</p>
</li>
<li><h5 id="必须使用成员初始化的四种情况："><a href="#必须使用成员初始化的四种情况：" class="headerlink" title="必须使用成员初始化的四种情况："></a>必须使用成员初始化的四种情况：</h5><ol>
<li>当初始化一个引用成员时；</li>
<li>当初始化一个常量成员时；</li>
<li>当调用一组基类的构造函数，而它应有一组参数时；</li>
<li>当调用一个成员函数的构造函数，而它有一组参数时； </li>
</ol>
</li>
</ol>
<h4 id="12-构造函数为什么不能为虚函数，析构函数为什么要虚函数"><a href="#12-构造函数为什么不能为虚函数，析构函数为什么要虚函数" class="headerlink" title="12. 构造函数为什么不能为虚函数，析构函数为什么要虚函数"></a><strong>12. 构造函数为什么不能为虚函数，析构函数为什么要虚函数</strong></h4><ol>
<li>构造函数本身是为了明确初始化对象成员才产生的，virtual function主要是为了在不完全了解细节的情况也能处理对象。另外，virtual函数是在不同类型的对象产生不同的动作，对象没产生的情况下，无法使用virtual函数完成动作。</li>
<li>C++中基类采用virtual虚析构函数是为了放置内存泄漏。具体的，如果派生类中申请了内存空间，并在其析构函数中对这些内存空间进行释放，假设基类中采用的是非虚析构函数，当删除基类指针指向的派生类对象时，*<u>就不会触发动态绑定</u>*，因而只会调用基类的析构函数，而不会调用派生类的析构函数。那么在这种情况下，派生类中申请的空间就得不到释放从而产生内存泄漏。因此C++基类中的析构函数应该采用virtual析构函数。</li>
</ol>
<h4 id="13-智能指针"><a href="#13-智能指针" class="headerlink" title="13 智能指针"></a>13 智能指针</h4><p>引用地址： <a href="https://zsmj2017.tech/post/8043ddb1.html" target="_blank" rel="noopener">https://zsmj2017.tech/post/8043ddb1.html</a>  </p>
<p><strong>原始指针的缺点</strong>：</p>
<ol>
<li>不能从声明中推断出是单一对象还是数组，</li>
<li>不能从声明中推断出使用完毕后是否应当销毁指针对象，也不知道用啥方式销毁（delete 还是专有方式销毁）</li>
<li>明确要销毁时候，就不知道是要delete 还是delete[];</li>
</ol>
<p>四个智能指针：auto_ptr, unique_ptr,shared_ptr  weak_ptr 。这些指针目的在于帮助管理动态分配对象的生命周期，通过保证在适当的时候以适当的方法销毁这些对象来避免资源泄漏。</p>
<p><strong>在进行独占式资源管理时使用std::unique_ptr</strong>  ： unique的指针大小与原始指针相同，可在以内存吃紧，实时性较高的场合中使用他们。任何一个非空的unique_ptr总是唯一拥有其指向资源。可以与shared_ptr进行相互转化。</p>
<p><strong>在进行共享式资源管理时使用  shared_ptr</strong> ：</p>
<p><strong>类shared_ptr但可空悬的智能指针</strong> weak_ptr： 类似于shared_ptr, 但不参与资源共享？不是很明白。<a href="https://zsmj2017.tech/post/bf8718e1.html" target="_blank" rel="noopener">https://zsmj2017.tech/post/bf8718e1.html</a></p>
<h4 id="14-new与maolloc-的区别"><a href="#14-new与maolloc-的区别" class="headerlink" title="14 new与maolloc 的区别"></a>14 new与maolloc 的区别</h4><ol>
<li>new与malloc都实现了在堆区的内存地址的申请，new/delete是靠malloc与free底层实现的。</li>
<li>new/delete是C++的关键字，而malloc与free是库函数，需要头文件支持。</li>
<li>使用new操作符申请内存空间分配时无需要指定内存块的大小，编译器会根据类型信息自行计算。而malloc则需要显示的指出所需内存的尺寸。</li>
<li>new 操作符在内存分配成功之后会返回对象类型的指针，类型严格与对象匹配，无需进行类型转换，因此new是符合安全类型安全的操作符。而malloc内存分配成功之后需要强制类型转换转换成我们想要的类型。</li>
<li>new在内存分配失败时候，会抛出异常，malloc 失败会返回NULL</li>
<li>释放空间时：new-delete ，malloc-free。</li>
</ol>
<h4 id="C-多态的实现"><a href="#C-多态的实现" class="headerlink" title="C++多态的实现"></a>C++多态的实现</h4><p><strong>1. 静态多态</strong>（重载与模板）：在编译阶段确定调用函数的类型。</p>
<p><strong>2. 动态多态：</strong>：（覆盖，虚函数实现）在运行的时候才能够调用是哪个函数，动态绑定，运行基类指针指向派生类的对象，并调用派生类的函数。</p>
<p><strong>虚函数的原理</strong>： 虚函数表与虚函数指针。</p>
<h4 id="编译与执行的四个阶段"><a href="#编译与执行的四个阶段" class="headerlink" title="编译与执行的四个阶段"></a>编译与执行的四个阶段</h4><p>代码的编译过程分为编译与连接两个过程</p>
<p><img src="https://img-blog.csdn.net/20161012213642133?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center" alt="img"></p>
<p>编译过程又分为编译与汇编。</p>
<p><strong><u><em>编译</em></u></strong>：读取源程序（字符流），对之进行词法和语法分析，将高级语言指令转换为功能等效的汇编代码。源文件的编译的过程分为两部分。</p>
<p><strong>预处理阶段</strong>: 进行以下几个方面的处理</p>
<ol>
<li>宏定义指令：#define a b</li>
<li>条件预编译指令： #ifdef, #ifndef, #else, #elif ,# endif 等。</li>
<li>头文件包含：#include </li>
</ol>
<p><strong>第二阶段编译：优化阶段</strong></p>
<p>编译程序所要做的工作就是通过词法分析与语法分析，在确认所有的指令都符合语法规则之后，将其翻译成等价的中间代码或是汇编代码。</p>
<p><strong>优化阶段</strong>：</p>
<ol>
<li>对中间代码的优化，删除公共表达式，循环优化（代码外提，强度削弱，变量循环控制），腹泻传播；</li>
<li>针对代码的生成进行，同机器的硬件结构密切相关，主要考虑的是如何充分利用机器的各个硬件寄存器存放相关变量，以减少对内存的访问次数。</li>
</ol>
<p><strong>*<u>汇编</u>*</strong>： 汇编实际上指把汇编代码发已成目标机器指令的过程。对于被翻译系统处理的每一个C语言源程序，最终经过这一处理得到相应的目标代码文件。一个目标文件中至少有两个段：</p>
<ol>
<li><strong>代码段</strong>： 包含程序的指令，可读，可执行，不可写。</li>
<li><strong>数据段</strong>： 主要存放在程序中要用到的全局变量与静态变量，可读可写可执行；</li>
</ol>
<p><strong><u><em>连接</em></u></strong>： 将有关的文件彼此相连接，使得所有的这些目标文件成为一个能够被操作系统装入执行的统一整体。</p>
<p>连接处理可分为两种：</p>
<p><strong>静态链接</strong>：函数的代码将其所在的静态连接库中被拷贝到最终的可执行程序中。这样在被执行是代码将被装入进程的虚拟空间中。</p>
<p><strong>动态链接</strong>： 函数的代码将被放在成为动态链接库或共享对象的某个目标文件中。</p>
<p>在linux使用的GCC将以上几个过程进行捆绑。</p>
<p><img src="https://img-blog.csdn.net/20161012213659383?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center" alt="img"></p>
<p><strong>预编译、编译、汇编、链接</strong></p>
<p>参考链接：2019年题目：<a href="https://blog.csdn.net/qq_38410730/article/details/80951443" target="_blank" rel="noopener">https://blog.csdn.net/qq_38410730/article/details/80951443</a></p>
<h4 id="程序占用的内存："><a href="#程序占用的内存：" class="headerlink" title="程序占用的内存："></a>程序占用的内存：</h4><p>每个线程都会有自己的栈，但是堆空间是共用的。</p>
<ol>
<li>栈区（stack）：由编译器自动分配释放在编译期间就能确定存储大小，存放函数的参数值，局部变量值以及函数的返回值。操作方式和数据结构中的栈类似，按照内存地址由高到低生长，速度快，但自由行差，最大空间不大（VC编译器的默认栈的大小为1M）。</li>
<li>堆区（heap）：存放new或者malloc申请的对象，需要手动释放，如果没有释放，程序结束时候由OS回收；堆由高地址向低地址生长。堆的大小一般没有限制，理论上每个程序最大可达到4G。</li>
<li>静态（全局）区（static）：全局变量和静态变量存储的区域，程序结束后由系统释放。</li>
<li>常量存储区：存放的是常量，不可以修改，全局可见；</li>
<li>代码存储区：存储二进制代码</li>
<li>关于堆、栈对比</li>
</ol>
<table>
<thead>
<tr>
<th></th>
<th>栈</th>
<th>堆</th>
</tr>
</thead>
<tbody><tr>
<td>存储内容</td>
<td>局部变量、形参、函数返回值</td>
<td>new、malloc申请的地址</td>
</tr>
<tr>
<td>作用域</td>
<td>函数作用域、语句块作用域</td>
<td>函数作用域</td>
</tr>
<tr>
<td>编译期间是否确定大小</td>
<td>是</td>
<td>否</td>
</tr>
<tr>
<td>大小</td>
<td>1M</td>
<td>4GB</td>
</tr>
<tr>
<td>内存分配方式</td>
<td>地址由高到低的减少</td>
<td>地址由低到高</td>
</tr>
<tr>
<td>内存是否可以修改</td>
<td>是</td>
<td>是</td>
</tr>
</tbody></table>
<p><img src="http://hi.csdn.net/attachment/201202/21/0_1329798989zO3K.gif" alt="img"></p>

  </article>
</div>


    




</div>

<div class="footer-wrapper container">
  <footer class="footer clearfix">
    <div class="clearfix">
    <a href="https://haitao926.github.io" class="footer-logo">
      <i class="fa fa-github"></i>
    </a>
    <ul class="footer-social-link">
      <li>© 2019 haitaoW</li>
      <li><a href="https://haitao926.github.io">Home</a></li>
      
      <li><a href="https://github.com/haitao926">Github</a></li>
      
    </ul>
    <div class="footer-theme-info">
      Theme <a href="//github.com/sabrinaluo/hexo-theme-replica">Replica</a>
      by <a href="//github.com/sabrinaluo">Hiitea</a> ❤ Powered by Hexo
    </div>
    </div>
    
  </footer>
</div>




<script src="/js/main.js"></script>

</body>
</html>
